//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS DeviceFarm service.
///
/// Welcome to the AWS Device Farm API documentation, which contains APIs for:   Testing on desktop browsers Device Farm makes it possible for you to test your web applications on desktop browsers using Selenium. The APIs for desktop browser testing contain TestGrid in their names. For more information, see Testing Web Applications on Selenium with Device Farm.   Testing on real mobile devices Device Farm makes it possible for you to test apps on physical phones, tablets, and other devices in the cloud. For more information, see the Device Farm Developer Guide.
public struct DeviceFarm: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the DeviceFarm client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            amzTarget: "DeviceFarm_20150623",
            serviceName: "DeviceFarm",
            serviceIdentifier: "devicefarm",
            serviceProtocol: .json(version: "1.1"),
            apiVersion: "2015-06-23",
            endpoint: endpoint,
            errorType: DeviceFarmErrorType.self,
            xmlNamespace: "http://devicefarm.amazonaws.com/doc/2015-06-23/",
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    /// Creates a device pool.
    @Sendable
    @inlinable
    public func createDevicePool(_ input: CreateDevicePoolRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateDevicePoolResult {
        try await self.client.execute(
            operation: "CreateDevicePool", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a device pool.
    ///
    /// Parameters:
    ///   - description: The device pool's description.
    ///   - maxDevices: The number of devices that Device Farm can add to your device pool. Device Farm adds devices that are available and meet the criteria that you assign for the rules parameter. Depending on how many devices meet these constraints, your device pool might contain fewer devices than the value for this parameter. By specifying the maximum number of devices, you can control the costs that you incur by running tests.
    ///   - name: The device pool's name.
    ///   - projectArn: The ARN of the project for the device pool.
    ///   - rules: The device pool's rules.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDevicePool(
        description: String? = nil,
        maxDevices: Int? = nil,
        name: String,
        projectArn: String,
        rules: [Rule],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDevicePoolResult {
        let input = CreateDevicePoolRequest(
            description: description, 
            maxDevices: maxDevices, 
            name: name, 
            projectArn: projectArn, 
            rules: rules
        )
        return try await self.createDevicePool(input, logger: logger)
    }

    /// Creates a profile that can be applied to one or more private fleet device instances.
    @Sendable
    @inlinable
    public func createInstanceProfile(_ input: CreateInstanceProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateInstanceProfileResult {
        try await self.client.execute(
            operation: "CreateInstanceProfile", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a profile that can be applied to one or more private fleet device instances.
    ///
    /// Parameters:
    ///   - description: The description of your instance profile.
    ///   - excludeAppPackagesFromCleanup: An array of strings that specifies the list of app packages that should not be cleaned up from the device after a test run. The list of packages is considered only if you set packageCleanup to true.
    ///   - name: The name of your instance profile.
    ///   - packageCleanup: When set to true, Device Farm removes app packages after a test run. The default value is false for private devices.
    ///   - rebootAfterUse: When set to true, Device Farm reboots the instance after a test run. The default value is true.
    ///   - logger: Logger use during operation
    @inlinable
    public func createInstanceProfile(
        description: String? = nil,
        excludeAppPackagesFromCleanup: [String]? = nil,
        name: String,
        packageCleanup: Bool? = nil,
        rebootAfterUse: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateInstanceProfileResult {
        let input = CreateInstanceProfileRequest(
            description: description, 
            excludeAppPackagesFromCleanup: excludeAppPackagesFromCleanup, 
            name: name, 
            packageCleanup: packageCleanup, 
            rebootAfterUse: rebootAfterUse
        )
        return try await self.createInstanceProfile(input, logger: logger)
    }

    /// Creates a network profile.
    @Sendable
    @inlinable
    public func createNetworkProfile(_ input: CreateNetworkProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateNetworkProfileResult {
        try await self.client.execute(
            operation: "CreateNetworkProfile", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a network profile.
    ///
    /// Parameters:
    ///   - description: The description of the network profile.
    ///   - downlinkBandwidthBits: The data throughput rate in bits per second, as an integer from 0 to 104857600.
    ///   - downlinkDelayMs: Delay time for all packets to destination in milliseconds as an integer from 0 to 2000.
    ///   - downlinkJitterMs: Time variation in the delay of received packets in milliseconds as an integer from 0 to 2000.
    ///   - downlinkLossPercent: Proportion of received packets that fail to arrive from 0 to 100 percent.
    ///   - name: The name for the new network profile.
    ///   - projectArn: The Amazon Resource Name (ARN) of the project for which you want to create a network profile.
    ///   - type: The type of network profile to create. Valid values are listed here.
    ///   - uplinkBandwidthBits: The data throughput rate in bits per second, as an integer from 0 to 104857600.
    ///   - uplinkDelayMs: Delay time for all packets to destination in milliseconds as an integer from 0 to 2000.
    ///   - uplinkJitterMs: Time variation in the delay of received packets in milliseconds as an integer from 0 to 2000.
    ///   - uplinkLossPercent: Proportion of transmitted packets that fail to arrive from 0 to 100 percent.
    ///   - logger: Logger use during operation
    @inlinable
    public func createNetworkProfile(
        description: String? = nil,
        downlinkBandwidthBits: Int64? = nil,
        downlinkDelayMs: Int64? = nil,
        downlinkJitterMs: Int64? = nil,
        downlinkLossPercent: Int? = nil,
        name: String,
        projectArn: String,
        type: NetworkProfileType? = nil,
        uplinkBandwidthBits: Int64? = nil,
        uplinkDelayMs: Int64? = nil,
        uplinkJitterMs: Int64? = nil,
        uplinkLossPercent: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateNetworkProfileResult {
        let input = CreateNetworkProfileRequest(
            description: description, 
            downlinkBandwidthBits: downlinkBandwidthBits, 
            downlinkDelayMs: downlinkDelayMs, 
            downlinkJitterMs: downlinkJitterMs, 
            downlinkLossPercent: downlinkLossPercent, 
            name: name, 
            projectArn: projectArn, 
            type: type, 
            uplinkBandwidthBits: uplinkBandwidthBits, 
            uplinkDelayMs: uplinkDelayMs, 
            uplinkJitterMs: uplinkJitterMs, 
            uplinkLossPercent: uplinkLossPercent
        )
        return try await self.createNetworkProfile(input, logger: logger)
    }

    /// Creates a project.
    @Sendable
    @inlinable
    public func createProject(_ input: CreateProjectRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateProjectResult {
        try await self.client.execute(
            operation: "CreateProject", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a project.
    ///
    /// Parameters:
    ///   - defaultJobTimeoutMinutes: Sets the execution timeout value (in minutes) for a project. All test runs in this project use the specified execution timeout value unless overridden when scheduling a run.
    ///   - name: The project's name.
    ///   - vpcConfig: The VPC security groups and subnets that are attached to a project.
    ///   - logger: Logger use during operation
    @inlinable
    public func createProject(
        defaultJobTimeoutMinutes: Int? = nil,
        name: String,
        vpcConfig: VpcConfig? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateProjectResult {
        let input = CreateProjectRequest(
            defaultJobTimeoutMinutes: defaultJobTimeoutMinutes, 
            name: name, 
            vpcConfig: vpcConfig
        )
        return try await self.createProject(input, logger: logger)
    }

    /// Specifies and starts a remote access session.
    @Sendable
    @inlinable
    public func createRemoteAccessSession(_ input: CreateRemoteAccessSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateRemoteAccessSessionResult {
        try await self.client.execute(
            operation: "CreateRemoteAccessSession", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Specifies and starts a remote access session.
    ///
    /// Parameters:
    ///   - clientId: Unique identifier for the client. If you want access to multiple devices on the same client, you should pass the same clientId value in each call to CreateRemoteAccessSession. This identifier is required only if remoteDebugEnabled is set to true. Remote debugging is no longer supported.
    ///   - configuration: The configuration information for the remote access session request.
    ///   - deviceArn: The ARN of the device for which you want to create a remote access session.
    ///   - instanceArn: The Amazon Resource Name (ARN) of the device instance for which you want to create a remote access session.
    ///   - interactionMode: The interaction mode of the remote access session. Valid values are:   INTERACTIVE: You can interact with the iOS device by viewing, touching, and rotating the screen. You cannot run XCUITest framework-based tests in this mode.   NO_VIDEO: You are connected to the device, but cannot interact with it or view the screen. This mode has the fastest test execution speed. You can run XCUITest framework-based tests in this mode.   VIDEO_ONLY: You can view the screen, but cannot touch or rotate it. You can run XCUITest framework-based tests and watch the screen in this mode.
    ///   - name: The name of the remote access session to create.
    ///   - projectArn: The Amazon Resource Name (ARN) of the project for which you want to create a remote access session.
    ///   - remoteDebugEnabled: Set to true if you want to access devices remotely for debugging in your remote access session. Remote debugging is no longer supported.
    ///   - remoteRecordAppArn: The Amazon Resource Name (ARN) for the app to be recorded in the remote access session.
    ///   - remoteRecordEnabled: Set to true to enable remote recording for the remote access session.
    ///   - skipAppResign: When set to true, for private devices, Device Farm does not sign your app again. For public devices, Device Farm always signs your apps again. For more information on how Device Farm modifies your uploads during tests, see Do you modify my app?
    ///   - sshPublicKey: Ignored. The public key of the ssh key pair you want to use for connecting to remote devices in your remote debugging session. This key is required only if remoteDebugEnabled is set to true. Remote debugging is no longer supported.
    ///   - logger: Logger use during operation
    @inlinable
    public func createRemoteAccessSession(
        clientId: String? = nil,
        configuration: CreateRemoteAccessSessionConfiguration? = nil,
        deviceArn: String,
        instanceArn: String? = nil,
        interactionMode: InteractionMode? = nil,
        name: String? = nil,
        projectArn: String,
        remoteDebugEnabled: Bool? = nil,
        remoteRecordAppArn: String? = nil,
        remoteRecordEnabled: Bool? = nil,
        skipAppResign: Bool? = nil,
        sshPublicKey: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateRemoteAccessSessionResult {
        let input = CreateRemoteAccessSessionRequest(
            clientId: clientId, 
            configuration: configuration, 
            deviceArn: deviceArn, 
            instanceArn: instanceArn, 
            interactionMode: interactionMode, 
            name: name, 
            projectArn: projectArn, 
            remoteDebugEnabled: remoteDebugEnabled, 
            remoteRecordAppArn: remoteRecordAppArn, 
            remoteRecordEnabled: remoteRecordEnabled, 
            skipAppResign: skipAppResign, 
            sshPublicKey: sshPublicKey
        )
        return try await self.createRemoteAccessSession(input, logger: logger)
    }

    /// Creates a Selenium testing project. Projects are used to track TestGridSession instances.
    @Sendable
    @inlinable
    public func createTestGridProject(_ input: CreateTestGridProjectRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateTestGridProjectResult {
        try await self.client.execute(
            operation: "CreateTestGridProject", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a Selenium testing project. Projects are used to track TestGridSession instances.
    ///
    /// Parameters:
    ///   - description: Human-readable description of the project.
    ///   - name: Human-readable name of the Selenium testing project.
    ///   - vpcConfig: The VPC security groups and subnets that are attached to a project.
    ///   - logger: Logger use during operation
    @inlinable
    public func createTestGridProject(
        description: String? = nil,
        name: String,
        vpcConfig: TestGridVpcConfig? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateTestGridProjectResult {
        let input = CreateTestGridProjectRequest(
            description: description, 
            name: name, 
            vpcConfig: vpcConfig
        )
        return try await self.createTestGridProject(input, logger: logger)
    }

    /// Creates a signed, short-term URL that can be passed to a Selenium RemoteWebDriver constructor.
    @Sendable
    @inlinable
    public func createTestGridUrl(_ input: CreateTestGridUrlRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateTestGridUrlResult {
        try await self.client.execute(
            operation: "CreateTestGridUrl", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a signed, short-term URL that can be passed to a Selenium RemoteWebDriver constructor.
    ///
    /// Parameters:
    ///   - expiresInSeconds: Lifetime, in seconds, of the URL.
    ///   - projectArn: ARN (from CreateTestGridProject or ListTestGridProjects) to associate with the short-term URL.
    ///   - logger: Logger use during operation
    @inlinable
    public func createTestGridUrl(
        expiresInSeconds: Int,
        projectArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateTestGridUrlResult {
        let input = CreateTestGridUrlRequest(
            expiresInSeconds: expiresInSeconds, 
            projectArn: projectArn
        )
        return try await self.createTestGridUrl(input, logger: logger)
    }

    /// Uploads an app or test scripts.
    @Sendable
    @inlinable
    public func createUpload(_ input: CreateUploadRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateUploadResult {
        try await self.client.execute(
            operation: "CreateUpload", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Uploads an app or test scripts.
    ///
    /// Parameters:
    ///   - contentType: The upload's content type (for example, application/octet-stream).
    ///   - name: The upload's file name. The name should not contain any forward slashes (/). If you are uploading an iOS app, the file name must end with the .ipa extension. If you are uploading an Android app, the file name must end with the .apk extension. For all others, the file name must end with the .zip file extension.
    ///   - projectArn: The ARN of the project for the upload.
    ///   - type: The upload's upload type. Must be one of the following values:   ANDROID_APP   IOS_APP   WEB_APP   EXTERNAL_DATA   APPIUM_JAVA_JUNIT_TEST_PACKAGE   APPIUM_JAVA_TESTNG_TEST_PACKAGE   APPIUM_PYTHON_TEST_PACKAGE   APPIUM_NODE_TEST_PACKAGE   APPIUM_RUBY_TEST_PACKAGE   APPIUM_WEB_JAVA_JUNIT_TEST_PACKAGE   APPIUM_WEB_JAVA_TESTNG_TEST_PACKAGE   APPIUM_WEB_PYTHON_TEST_PACKAGE   APPIUM_WEB_NODE_TEST_PACKAGE   APPIUM_WEB_RUBY_TEST_PACKAGE   INSTRUMENTATION_TEST_PACKAGE   XCTEST_TEST_PACKAGE   XCTEST_UI_TEST_PACKAGE   APPIUM_JAVA_JUNIT_TEST_SPEC   APPIUM_JAVA_TESTNG_TEST_SPEC   APPIUM_PYTHON_TEST_SPEC   APPIUM_NODE_TEST_SPEC   APPIUM_RUBY_TEST_SPEC   APPIUM_WEB_JAVA_JUNIT_TEST_SPEC   APPIUM_WEB_JAVA_TESTNG_TEST_SPEC   APPIUM_WEB_PYTHON_TEST_SPEC   APPIUM_WEB_NODE_TEST_SPEC   APPIUM_WEB_RUBY_TEST_SPEC   INSTRUMENTATION_TEST_SPEC   XCTEST_UI_TEST_SPEC   If you call CreateUpload with WEB_APP specified, AWS Device Farm throws an ArgumentException error.
    ///   - logger: Logger use during operation
    @inlinable
    public func createUpload(
        contentType: String? = nil,
        name: String,
        projectArn: String,
        type: UploadType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateUploadResult {
        let input = CreateUploadRequest(
            contentType: contentType, 
            name: name, 
            projectArn: projectArn, 
            type: type
        )
        return try await self.createUpload(input, logger: logger)
    }

    /// Creates a configuration record in Device Farm for your Amazon Virtual Private Cloud (VPC) endpoint.
    @Sendable
    @inlinable
    public func createVPCEConfiguration(_ input: CreateVPCEConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateVPCEConfigurationResult {
        try await self.client.execute(
            operation: "CreateVPCEConfiguration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a configuration record in Device Farm for your Amazon Virtual Private Cloud (VPC) endpoint.
    ///
    /// Parameters:
    ///   - serviceDnsName: The DNS name of the service running in your VPC that you want Device Farm to test.
    ///   - vpceConfigurationDescription: An optional description that provides details about your VPC endpoint configuration.
    ///   - vpceConfigurationName: The friendly name you give to your VPC endpoint configuration, to manage your configurations more easily.
    ///   - vpceServiceName: The name of the VPC endpoint service running in your AWS account that you want Device Farm to test.
    ///   - logger: Logger use during operation
    @inlinable
    public func createVPCEConfiguration(
        serviceDnsName: String,
        vpceConfigurationDescription: String? = nil,
        vpceConfigurationName: String,
        vpceServiceName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateVPCEConfigurationResult {
        let input = CreateVPCEConfigurationRequest(
            serviceDnsName: serviceDnsName, 
            vpceConfigurationDescription: vpceConfigurationDescription, 
            vpceConfigurationName: vpceConfigurationName, 
            vpceServiceName: vpceServiceName
        )
        return try await self.createVPCEConfiguration(input, logger: logger)
    }

    /// Deletes a device pool given the pool ARN. Does not allow deletion of curated pools owned by the system.
    @Sendable
    @inlinable
    public func deleteDevicePool(_ input: DeleteDevicePoolRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteDevicePoolResult {
        try await self.client.execute(
            operation: "DeleteDevicePool", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a device pool given the pool ARN. Does not allow deletion of curated pools owned by the system.
    ///
    /// Parameters:
    ///   - arn: Represents the Amazon Resource Name (ARN) of the Device Farm device pool to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDevicePool(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteDevicePoolResult {
        let input = DeleteDevicePoolRequest(
            arn: arn
        )
        return try await self.deleteDevicePool(input, logger: logger)
    }

    /// Deletes a profile that can be applied to one or more private device instances.
    @Sendable
    @inlinable
    public func deleteInstanceProfile(_ input: DeleteInstanceProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteInstanceProfileResult {
        try await self.client.execute(
            operation: "DeleteInstanceProfile", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a profile that can be applied to one or more private device instances.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the instance profile you are requesting to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteInstanceProfile(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteInstanceProfileResult {
        let input = DeleteInstanceProfileRequest(
            arn: arn
        )
        return try await self.deleteInstanceProfile(input, logger: logger)
    }

    /// Deletes a network profile.
    @Sendable
    @inlinable
    public func deleteNetworkProfile(_ input: DeleteNetworkProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteNetworkProfileResult {
        try await self.client.execute(
            operation: "DeleteNetworkProfile", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a network profile.
    ///
    /// Parameters:
    ///   - arn: The ARN of the network profile to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteNetworkProfile(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteNetworkProfileResult {
        let input = DeleteNetworkProfileRequest(
            arn: arn
        )
        return try await self.deleteNetworkProfile(input, logger: logger)
    }

    /// Deletes an AWS Device Farm project, given the project ARN. Deleting this resource does not stop an in-progress run.
    @Sendable
    @inlinable
    public func deleteProject(_ input: DeleteProjectRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteProjectResult {
        try await self.client.execute(
            operation: "DeleteProject", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an AWS Device Farm project, given the project ARN. Deleting this resource does not stop an in-progress run.
    ///
    /// Parameters:
    ///   - arn: Represents the Amazon Resource Name (ARN) of the Device Farm project to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteProject(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteProjectResult {
        let input = DeleteProjectRequest(
            arn: arn
        )
        return try await self.deleteProject(input, logger: logger)
    }

    /// Deletes a completed remote access session and its results.
    @Sendable
    @inlinable
    public func deleteRemoteAccessSession(_ input: DeleteRemoteAccessSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteRemoteAccessSessionResult {
        try await self.client.execute(
            operation: "DeleteRemoteAccessSession", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a completed remote access session and its results.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the session for which you want to delete remote access.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteRemoteAccessSession(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteRemoteAccessSessionResult {
        let input = DeleteRemoteAccessSessionRequest(
            arn: arn
        )
        return try await self.deleteRemoteAccessSession(input, logger: logger)
    }

    /// Deletes the run, given the run ARN. Deleting this resource does not stop an in-progress run.
    @Sendable
    @inlinable
    public func deleteRun(_ input: DeleteRunRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteRunResult {
        try await self.client.execute(
            operation: "DeleteRun", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the run, given the run ARN. Deleting this resource does not stop an in-progress run.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) for the run to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteRun(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteRunResult {
        let input = DeleteRunRequest(
            arn: arn
        )
        return try await self.deleteRun(input, logger: logger)
    }

    ///  Deletes a Selenium testing project and all content generated under it.   You cannot undo this operation.   You cannot delete a project if it has active sessions.
    @Sendable
    @inlinable
    public func deleteTestGridProject(_ input: DeleteTestGridProjectRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteTestGridProjectResult {
        try await self.client.execute(
            operation: "DeleteTestGridProject", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes a Selenium testing project and all content generated under it.   You cannot undo this operation.   You cannot delete a project if it has active sessions.
    ///
    /// Parameters:
    ///   - projectArn: The ARN of the project to delete, from CreateTestGridProject or ListTestGridProjects.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteTestGridProject(
        projectArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteTestGridProjectResult {
        let input = DeleteTestGridProjectRequest(
            projectArn: projectArn
        )
        return try await self.deleteTestGridProject(input, logger: logger)
    }

    /// Deletes an upload given the upload ARN.
    @Sendable
    @inlinable
    public func deleteUpload(_ input: DeleteUploadRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteUploadResult {
        try await self.client.execute(
            operation: "DeleteUpload", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an upload given the upload ARN.
    ///
    /// Parameters:
    ///   - arn: Represents the Amazon Resource Name (ARN) of the Device Farm upload to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteUpload(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteUploadResult {
        let input = DeleteUploadRequest(
            arn: arn
        )
        return try await self.deleteUpload(input, logger: logger)
    }

    /// Deletes a configuration for your Amazon Virtual Private Cloud (VPC) endpoint.
    @Sendable
    @inlinable
    public func deleteVPCEConfiguration(_ input: DeleteVPCEConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteVPCEConfigurationResult {
        try await self.client.execute(
            operation: "DeleteVPCEConfiguration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a configuration for your Amazon Virtual Private Cloud (VPC) endpoint.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the VPC endpoint configuration you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteVPCEConfiguration(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteVPCEConfigurationResult {
        let input = DeleteVPCEConfigurationRequest(
            arn: arn
        )
        return try await self.deleteVPCEConfiguration(input, logger: logger)
    }

    /// Returns the number of unmetered iOS or unmetered Android devices that have been purchased by the account.
    @Sendable
    @inlinable
    public func getAccountSettings(_ input: GetAccountSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAccountSettingsResult {
        try await self.client.execute(
            operation: "GetAccountSettings", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the number of unmetered iOS or unmetered Android devices that have been purchased by the account.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getAccountSettings(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAccountSettingsResult {
        let input = GetAccountSettingsRequest(
        )
        return try await self.getAccountSettings(input, logger: logger)
    }

    /// Gets information about a unique device type.
    @Sendable
    @inlinable
    public func getDevice(_ input: GetDeviceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDeviceResult {
        try await self.client.execute(
            operation: "GetDevice", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a unique device type.
    ///
    /// Parameters:
    ///   - arn: The device type's ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDevice(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDeviceResult {
        let input = GetDeviceRequest(
            arn: arn
        )
        return try await self.getDevice(input, logger: logger)
    }

    /// Returns information about a device instance that belongs to a private device fleet.
    @Sendable
    @inlinable
    public func getDeviceInstance(_ input: GetDeviceInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDeviceInstanceResult {
        try await self.client.execute(
            operation: "GetDeviceInstance", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a device instance that belongs to a private device fleet.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the instance you're requesting information about.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDeviceInstance(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDeviceInstanceResult {
        let input = GetDeviceInstanceRequest(
            arn: arn
        )
        return try await self.getDeviceInstance(input, logger: logger)
    }

    /// Gets information about a device pool.
    @Sendable
    @inlinable
    public func getDevicePool(_ input: GetDevicePoolRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDevicePoolResult {
        try await self.client.execute(
            operation: "GetDevicePool", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a device pool.
    ///
    /// Parameters:
    ///   - arn: The device pool's ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDevicePool(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDevicePoolResult {
        let input = GetDevicePoolRequest(
            arn: arn
        )
        return try await self.getDevicePool(input, logger: logger)
    }

    /// Gets information about compatibility with a device pool.
    @Sendable
    @inlinable
    public func getDevicePoolCompatibility(_ input: GetDevicePoolCompatibilityRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDevicePoolCompatibilityResult {
        try await self.client.execute(
            operation: "GetDevicePoolCompatibility", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about compatibility with a device pool.
    ///
    /// Parameters:
    ///   - appArn: The ARN of the app that is associated with the specified device pool.
    ///   - configuration: An object that contains information about the settings for a run.
    ///   - devicePoolArn: The device pool's ARN.
    ///   - projectArn: The ARN of the project for which you want to check device pool compatibility.
    ///   - test: Information about the uploaded test to be run against the device pool.
    ///   - testType: The test type for the specified device pool. Allowed values include the following:   BUILTIN_FUZZ.   APPIUM_JAVA_JUNIT.   APPIUM_JAVA_TESTNG.   APPIUM_PYTHON.   APPIUM_NODE.   APPIUM_RUBY.   APPIUM_WEB_JAVA_JUNIT.   APPIUM_WEB_JAVA_TESTNG.   APPIUM_WEB_PYTHON.   APPIUM_WEB_NODE.   APPIUM_WEB_RUBY.   INSTRUMENTATION.   XCTEST.   XCTEST_UI.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDevicePoolCompatibility(
        appArn: String? = nil,
        configuration: ScheduleRunConfiguration? = nil,
        devicePoolArn: String,
        projectArn: String? = nil,
        test: ScheduleRunTest? = nil,
        testType: TestType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDevicePoolCompatibilityResult {
        let input = GetDevicePoolCompatibilityRequest(
            appArn: appArn, 
            configuration: configuration, 
            devicePoolArn: devicePoolArn, 
            projectArn: projectArn, 
            test: test, 
            testType: testType
        )
        return try await self.getDevicePoolCompatibility(input, logger: logger)
    }

    /// Returns information about the specified instance profile.
    @Sendable
    @inlinable
    public func getInstanceProfile(_ input: GetInstanceProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetInstanceProfileResult {
        try await self.client.execute(
            operation: "GetInstanceProfile", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the specified instance profile.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of an instance profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func getInstanceProfile(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetInstanceProfileResult {
        let input = GetInstanceProfileRequest(
            arn: arn
        )
        return try await self.getInstanceProfile(input, logger: logger)
    }

    /// Gets information about a job.
    @Sendable
    @inlinable
    public func getJob(_ input: GetJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetJobResult {
        try await self.client.execute(
            operation: "GetJob", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a job.
    ///
    /// Parameters:
    ///   - arn: The job's ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getJob(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetJobResult {
        let input = GetJobRequest(
            arn: arn
        )
        return try await self.getJob(input, logger: logger)
    }

    /// Returns information about a network profile.
    @Sendable
    @inlinable
    public func getNetworkProfile(_ input: GetNetworkProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNetworkProfileResult {
        try await self.client.execute(
            operation: "GetNetworkProfile", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a network profile.
    ///
    /// Parameters:
    ///   - arn: The ARN of the network profile to return information about.
    ///   - logger: Logger use during operation
    @inlinable
    public func getNetworkProfile(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNetworkProfileResult {
        let input = GetNetworkProfileRequest(
            arn: arn
        )
        return try await self.getNetworkProfile(input, logger: logger)
    }

    /// Gets the current status and future status of all offerings purchased by an AWS account. The response indicates how many offerings are currently available and the offerings that will be available in the next period. The API returns a NotEligible error if the user is not permitted to invoke the operation. If you must be able to invoke this operation, contact aws-devicefarm-support@amazon.com.
    @Sendable
    @inlinable
    public func getOfferingStatus(_ input: GetOfferingStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetOfferingStatusResult {
        try await self.client.execute(
            operation: "GetOfferingStatus", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the current status and future status of all offerings purchased by an AWS account. The response indicates how many offerings are currently available and the offerings that will be available in the next period. The API returns a NotEligible error if the user is not permitted to invoke the operation. If you must be able to invoke this operation, contact aws-devicefarm-support@amazon.com.
    ///
    /// Parameters:
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func getOfferingStatus(
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetOfferingStatusResult {
        let input = GetOfferingStatusRequest(
            nextToken: nextToken
        )
        return try await self.getOfferingStatus(input, logger: logger)
    }

    /// Gets information about a project.
    @Sendable
    @inlinable
    public func getProject(_ input: GetProjectRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetProjectResult {
        try await self.client.execute(
            operation: "GetProject", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a project.
    ///
    /// Parameters:
    ///   - arn: The project's ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getProject(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetProjectResult {
        let input = GetProjectRequest(
            arn: arn
        )
        return try await self.getProject(input, logger: logger)
    }

    /// Returns a link to a currently running remote access session.
    @Sendable
    @inlinable
    public func getRemoteAccessSession(_ input: GetRemoteAccessSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRemoteAccessSessionResult {
        try await self.client.execute(
            operation: "GetRemoteAccessSession", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a link to a currently running remote access session.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the remote access session about which you want to get session information.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRemoteAccessSession(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRemoteAccessSessionResult {
        let input = GetRemoteAccessSessionRequest(
            arn: arn
        )
        return try await self.getRemoteAccessSession(input, logger: logger)
    }

    /// Gets information about a run.
    @Sendable
    @inlinable
    public func getRun(_ input: GetRunRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRunResult {
        try await self.client.execute(
            operation: "GetRun", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a run.
    ///
    /// Parameters:
    ///   - arn: The run's ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRun(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRunResult {
        let input = GetRunRequest(
            arn: arn
        )
        return try await self.getRun(input, logger: logger)
    }

    /// Gets information about a suite.
    @Sendable
    @inlinable
    public func getSuite(_ input: GetSuiteRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSuiteResult {
        try await self.client.execute(
            operation: "GetSuite", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a suite.
    ///
    /// Parameters:
    ///   - arn: The suite's ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSuite(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSuiteResult {
        let input = GetSuiteRequest(
            arn: arn
        )
        return try await self.getSuite(input, logger: logger)
    }

    /// Gets information about a test.
    @Sendable
    @inlinable
    public func getTest(_ input: GetTestRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTestResult {
        try await self.client.execute(
            operation: "GetTest", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a test.
    ///
    /// Parameters:
    ///   - arn: The test's ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTest(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTestResult {
        let input = GetTestRequest(
            arn: arn
        )
        return try await self.getTest(input, logger: logger)
    }

    /// Retrieves information about a Selenium testing project.
    @Sendable
    @inlinable
    public func getTestGridProject(_ input: GetTestGridProjectRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTestGridProjectResult {
        try await self.client.execute(
            operation: "GetTestGridProject", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a Selenium testing project.
    ///
    /// Parameters:
    ///   - projectArn: The ARN of the Selenium testing project, from either CreateTestGridProject or ListTestGridProjects.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTestGridProject(
        projectArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTestGridProjectResult {
        let input = GetTestGridProjectRequest(
            projectArn: projectArn
        )
        return try await self.getTestGridProject(input, logger: logger)
    }

    /// A session is an instance of a browser created through a RemoteWebDriver with the URL from CreateTestGridUrlResult$url. You can use the following to look up sessions:   The session ARN (GetTestGridSessionRequest$sessionArn).   The project ARN and a session ID (GetTestGridSessionRequest$projectArn and GetTestGridSessionRequest$sessionId).
    @Sendable
    @inlinable
    public func getTestGridSession(_ input: GetTestGridSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTestGridSessionResult {
        try await self.client.execute(
            operation: "GetTestGridSession", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// A session is an instance of a browser created through a RemoteWebDriver with the URL from CreateTestGridUrlResult$url. You can use the following to look up sessions:   The session ARN (GetTestGridSessionRequest$sessionArn).   The project ARN and a session ID (GetTestGridSessionRequest$projectArn and GetTestGridSessionRequest$sessionId).
    ///
    /// Parameters:
    ///   - projectArn: The ARN for the project that this session belongs to. See CreateTestGridProject and ListTestGridProjects.
    ///   - sessionArn: An ARN that uniquely identifies a TestGridSession.
    ///   - sessionId: An ID associated with this session.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTestGridSession(
        projectArn: String? = nil,
        sessionArn: String? = nil,
        sessionId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTestGridSessionResult {
        let input = GetTestGridSessionRequest(
            projectArn: projectArn, 
            sessionArn: sessionArn, 
            sessionId: sessionId
        )
        return try await self.getTestGridSession(input, logger: logger)
    }

    /// Gets information about an upload.
    @Sendable
    @inlinable
    public func getUpload(_ input: GetUploadRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetUploadResult {
        try await self.client.execute(
            operation: "GetUpload", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about an upload.
    ///
    /// Parameters:
    ///   - arn: The upload's ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func getUpload(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetUploadResult {
        let input = GetUploadRequest(
            arn: arn
        )
        return try await self.getUpload(input, logger: logger)
    }

    /// Returns information about the configuration settings for your Amazon Virtual Private Cloud (VPC) endpoint.
    @Sendable
    @inlinable
    public func getVPCEConfiguration(_ input: GetVPCEConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetVPCEConfigurationResult {
        try await self.client.execute(
            operation: "GetVPCEConfiguration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the configuration settings for your Amazon Virtual Private Cloud (VPC) endpoint.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the VPC endpoint configuration you want to describe.
    ///   - logger: Logger use during operation
    @inlinable
    public func getVPCEConfiguration(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetVPCEConfigurationResult {
        let input = GetVPCEConfigurationRequest(
            arn: arn
        )
        return try await self.getVPCEConfiguration(input, logger: logger)
    }

    /// Installs an application to the device in a remote access session. For Android applications, the file must be in .apk format. For iOS applications, the file must be in .ipa format.
    @Sendable
    @inlinable
    public func installToRemoteAccessSession(_ input: InstallToRemoteAccessSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> InstallToRemoteAccessSessionResult {
        try await self.client.execute(
            operation: "InstallToRemoteAccessSession", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Installs an application to the device in a remote access session. For Android applications, the file must be in .apk format. For iOS applications, the file must be in .ipa format.
    ///
    /// Parameters:
    ///   - appArn: The ARN of the app about which you are requesting information.
    ///   - remoteAccessSessionArn: The Amazon Resource Name (ARN) of the remote access session about which you are requesting information.
    ///   - logger: Logger use during operation
    @inlinable
    public func installToRemoteAccessSession(
        appArn: String,
        remoteAccessSessionArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> InstallToRemoteAccessSessionResult {
        let input = InstallToRemoteAccessSessionRequest(
            appArn: appArn, 
            remoteAccessSessionArn: remoteAccessSessionArn
        )
        return try await self.installToRemoteAccessSession(input, logger: logger)
    }

    /// Gets information about artifacts.
    @Sendable
    @inlinable
    public func listArtifacts(_ input: ListArtifactsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListArtifactsResult {
        try await self.client.execute(
            operation: "ListArtifacts", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about artifacts.
    ///
    /// Parameters:
    ///   - arn: The run, job, suite, or test ARN.
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - type: The artifacts' type. Allowed values include:   FILE   LOG   SCREENSHOT
    ///   - logger: Logger use during operation
    @inlinable
    public func listArtifacts(
        arn: String,
        nextToken: String? = nil,
        type: ArtifactCategory,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListArtifactsResult {
        let input = ListArtifactsRequest(
            arn: arn, 
            nextToken: nextToken, 
            type: type
        )
        return try await self.listArtifacts(input, logger: logger)
    }

    /// Returns information about the private device instances associated with one or more AWS accounts.
    @Sendable
    @inlinable
    public func listDeviceInstances(_ input: ListDeviceInstancesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDeviceInstancesResult {
        try await self.client.execute(
            operation: "ListDeviceInstances", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the private device instances associated with one or more AWS accounts.
    ///
    /// Parameters:
    ///   - maxResults: An integer that specifies the maximum number of items you want to return in the API response.
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDeviceInstances(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDeviceInstancesResult {
        let input = ListDeviceInstancesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDeviceInstances(input, logger: logger)
    }

    /// Gets information about device pools.
    @Sendable
    @inlinable
    public func listDevicePools(_ input: ListDevicePoolsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDevicePoolsResult {
        try await self.client.execute(
            operation: "ListDevicePools", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about device pools.
    ///
    /// Parameters:
    ///   - arn: The project ARN.
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - type: The device pools' type. Allowed values include:   CURATED: A device pool that is created and managed by AWS Device Farm.   PRIVATE: A device pool that is created and managed by the device pool developer.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDevicePools(
        arn: String,
        nextToken: String? = nil,
        type: DevicePoolType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDevicePoolsResult {
        let input = ListDevicePoolsRequest(
            arn: arn, 
            nextToken: nextToken, 
            type: type
        )
        return try await self.listDevicePools(input, logger: logger)
    }

    /// Gets information about unique device types.
    @Sendable
    @inlinable
    public func listDevices(_ input: ListDevicesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDevicesResult {
        try await self.client.execute(
            operation: "ListDevices", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about unique device types.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the project.
    ///   - filters: Used to select a set of devices. A filter is made up of an attribute, an operator, and one or more values.   Attribute: The aspect of a device such as platform or model used as the selection criteria in a device filter. Allowed values include:   ARN: The Amazon Resource Name (ARN) of the device (for example, arn:aws:devicefarm:us-west-2::device:12345Example).   PLATFORM: The device platform. Valid values are ANDROID or IOS.   OS_VERSION: The operating system version (for example, 10.3.2).   MODEL: The device model (for example, iPad 5th Gen).   AVAILABILITY: The current availability of the device. Valid values are AVAILABLE, HIGHLY_AVAILABLE, BUSY, or TEMPORARY_NOT_AVAILABLE.   FORM_FACTOR: The device form factor. Valid values are PHONE or TABLET.   MANUFACTURER: The device manufacturer (for example, Apple).   REMOTE_ACCESS_ENABLED: Whether the device is enabled for remote access. Valid values are TRUE or FALSE.   REMOTE_DEBUG_ENABLED: Whether the device is enabled for remote debugging. Valid values are TRUE or FALSE. Because remote debugging is no longer supported, this attribute is ignored.   INSTANCE_ARN: The Amazon Resource Name (ARN) of the device instance.   INSTANCE_LABELS: The label of the device instance.   FLEET_TYPE: The fleet type. Valid values are PUBLIC or PRIVATE.     Operator: The filter operator.   The EQUALS operator is available for every attribute except INSTANCE_LABELS.   The CONTAINS operator is available for the INSTANCE_LABELS and MODEL attributes.   The IN and NOT_IN operators are available for the ARN, OS_VERSION, MODEL, MANUFACTURER, and INSTANCE_ARN attributes.   The LESS_THAN, GREATER_THAN, LESS_THAN_OR_EQUALS, and GREATER_THAN_OR_EQUALS operators are also available for the OS_VERSION attribute.     Values: An array of one or more filter values.   The IN and NOT_IN operators take a values array that has one or more elements.   The other operators require an array with a single element.   In a request, the AVAILABILITY attribute takes the following values: AVAILABLE, HIGHLY_AVAILABLE, BUSY, or TEMPORARY_NOT_AVAILABLE.
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDevices(
        arn: String? = nil,
        filters: [DeviceFilter]? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDevicesResult {
        let input = ListDevicesRequest(
            arn: arn, 
            filters: filters, 
            nextToken: nextToken
        )
        return try await self.listDevices(input, logger: logger)
    }

    /// Returns information about all the instance profiles in an AWS account.
    @Sendable
    @inlinable
    public func listInstanceProfiles(_ input: ListInstanceProfilesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListInstanceProfilesResult {
        try await self.client.execute(
            operation: "ListInstanceProfiles", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about all the instance profiles in an AWS account.
    ///
    /// Parameters:
    ///   - maxResults: An integer that specifies the maximum number of items you want to return in the API response.
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listInstanceProfiles(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListInstanceProfilesResult {
        let input = ListInstanceProfilesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listInstanceProfiles(input, logger: logger)
    }

    /// Gets information about jobs for a given test run.
    @Sendable
    @inlinable
    public func listJobs(_ input: ListJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListJobsResult {
        try await self.client.execute(
            operation: "ListJobs", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about jobs for a given test run.
    ///
    /// Parameters:
    ///   - arn: The run's Amazon Resource Name (ARN).
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listJobs(
        arn: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListJobsResult {
        let input = ListJobsRequest(
            arn: arn, 
            nextToken: nextToken
        )
        return try await self.listJobs(input, logger: logger)
    }

    /// Returns the list of available network profiles.
    @Sendable
    @inlinable
    public func listNetworkProfiles(_ input: ListNetworkProfilesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListNetworkProfilesResult {
        try await self.client.execute(
            operation: "ListNetworkProfiles", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the list of available network profiles.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the project for which you want to list network profiles.
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - type: The type of network profile to return information about. Valid values are listed here.
    ///   - logger: Logger use during operation
    @inlinable
    public func listNetworkProfiles(
        arn: String,
        nextToken: String? = nil,
        type: NetworkProfileType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListNetworkProfilesResult {
        let input = ListNetworkProfilesRequest(
            arn: arn, 
            nextToken: nextToken, 
            type: type
        )
        return try await self.listNetworkProfiles(input, logger: logger)
    }

    /// Returns a list of offering promotions. Each offering promotion record contains the ID and description of the promotion. The API returns a NotEligible error if the caller is not permitted to invoke the operation. Contact aws-devicefarm-support@amazon.com if you must be able to invoke this operation.
    @Sendable
    @inlinable
    public func listOfferingPromotions(_ input: ListOfferingPromotionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOfferingPromotionsResult {
        try await self.client.execute(
            operation: "ListOfferingPromotions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of offering promotions. Each offering promotion record contains the ID and description of the promotion. The API returns a NotEligible error if the caller is not permitted to invoke the operation. Contact aws-devicefarm-support@amazon.com if you must be able to invoke this operation.
    ///
    /// Parameters:
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOfferingPromotions(
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOfferingPromotionsResult {
        let input = ListOfferingPromotionsRequest(
            nextToken: nextToken
        )
        return try await self.listOfferingPromotions(input, logger: logger)
    }

    /// Returns a list of all historical purchases, renewals, and system renewal transactions for an AWS account. The list is paginated and ordered by a descending timestamp (most recent transactions are first). The API returns a NotEligible error if the user is not permitted to invoke the operation. If you must be able to invoke this operation, contact aws-devicefarm-support@amazon.com.
    @Sendable
    @inlinable
    public func listOfferingTransactions(_ input: ListOfferingTransactionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOfferingTransactionsResult {
        try await self.client.execute(
            operation: "ListOfferingTransactions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of all historical purchases, renewals, and system renewal transactions for an AWS account. The list is paginated and ordered by a descending timestamp (most recent transactions are first). The API returns a NotEligible error if the user is not permitted to invoke the operation. If you must be able to invoke this operation, contact aws-devicefarm-support@amazon.com.
    ///
    /// Parameters:
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOfferingTransactions(
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOfferingTransactionsResult {
        let input = ListOfferingTransactionsRequest(
            nextToken: nextToken
        )
        return try await self.listOfferingTransactions(input, logger: logger)
    }

    /// Returns a list of products or offerings that the user can manage through the API. Each offering record indicates the recurring price per unit and the frequency for that offering. The API returns a NotEligible error if the user is not permitted to invoke the operation.  If you must be able to invoke this operation, contact aws-devicefarm-support@amazon.com.
    @Sendable
    @inlinable
    public func listOfferings(_ input: ListOfferingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOfferingsResult {
        try await self.client.execute(
            operation: "ListOfferings", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of products or offerings that the user can manage through the API. Each offering record indicates the recurring price per unit and the frequency for that offering. The API returns a NotEligible error if the user is not permitted to invoke the operation.  If you must be able to invoke this operation, contact aws-devicefarm-support@amazon.com.
    ///
    /// Parameters:
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOfferings(
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOfferingsResult {
        let input = ListOfferingsRequest(
            nextToken: nextToken
        )
        return try await self.listOfferings(input, logger: logger)
    }

    /// Gets information about projects.
    @Sendable
    @inlinable
    public func listProjects(_ input: ListProjectsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListProjectsResult {
        try await self.client.execute(
            operation: "ListProjects", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about projects.
    ///
    /// Parameters:
    ///   - arn: Optional. If no Amazon Resource Name (ARN) is specified, then AWS Device Farm returns a list of all projects for the AWS account. You can also specify a project ARN.
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listProjects(
        arn: String? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListProjectsResult {
        let input = ListProjectsRequest(
            arn: arn, 
            nextToken: nextToken
        )
        return try await self.listProjects(input, logger: logger)
    }

    /// Returns a list of all currently running remote access sessions.
    @Sendable
    @inlinable
    public func listRemoteAccessSessions(_ input: ListRemoteAccessSessionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRemoteAccessSessionsResult {
        try await self.client.execute(
            operation: "ListRemoteAccessSessions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of all currently running remote access sessions.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the project about which you are requesting information.
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRemoteAccessSessions(
        arn: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRemoteAccessSessionsResult {
        let input = ListRemoteAccessSessionsRequest(
            arn: arn, 
            nextToken: nextToken
        )
        return try await self.listRemoteAccessSessions(input, logger: logger)
    }

    /// Gets information about runs, given an AWS Device Farm project ARN.
    @Sendable
    @inlinable
    public func listRuns(_ input: ListRunsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRunsResult {
        try await self.client.execute(
            operation: "ListRuns", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about runs, given an AWS Device Farm project ARN.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the project for which you want to list runs.
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRuns(
        arn: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRunsResult {
        let input = ListRunsRequest(
            arn: arn, 
            nextToken: nextToken
        )
        return try await self.listRuns(input, logger: logger)
    }

    /// Gets information about samples, given an AWS Device Farm job ARN.
    @Sendable
    @inlinable
    public func listSamples(_ input: ListSamplesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSamplesResult {
        try await self.client.execute(
            operation: "ListSamples", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about samples, given an AWS Device Farm job ARN.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the job used to list samples.
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSamples(
        arn: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSamplesResult {
        let input = ListSamplesRequest(
            arn: arn, 
            nextToken: nextToken
        )
        return try await self.listSamples(input, logger: logger)
    }

    /// Gets information about test suites for a given job.
    @Sendable
    @inlinable
    public func listSuites(_ input: ListSuitesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSuitesResult {
        try await self.client.execute(
            operation: "ListSuites", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about test suites for a given job.
    ///
    /// Parameters:
    ///   - arn: The job's Amazon Resource Name (ARN).
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSuites(
        arn: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSuitesResult {
        let input = ListSuitesRequest(
            arn: arn, 
            nextToken: nextToken
        )
        return try await self.listSuites(input, logger: logger)
    }

    /// List the tags for an AWS Device Farm resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List the tags for an AWS Device Farm resource.
    ///
    /// Parameters:
    ///   - resourceARN: The Amazon Resource Name (ARN) of the resource or resources for which to list tags. You can associate tags with the following Device Farm resources: PROJECT, RUN, NETWORK_PROFILE, INSTANCE_PROFILE, DEVICE_INSTANCE, SESSION, DEVICE_POOL, DEVICE, and VPCE_CONFIGURATION.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceARN: resourceARN
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Gets a list of all Selenium testing projects in your account.
    @Sendable
    @inlinable
    public func listTestGridProjects(_ input: ListTestGridProjectsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTestGridProjectsResult {
        try await self.client.execute(
            operation: "ListTestGridProjects", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets a list of all Selenium testing projects in your account.
    ///
    /// Parameters:
    ///   - maxResult: Return no more than this number of results.
    ///   - nextToken: From a response, used to continue a paginated listing.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTestGridProjects(
        maxResult: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTestGridProjectsResult {
        let input = ListTestGridProjectsRequest(
            maxResult: maxResult, 
            nextToken: nextToken
        )
        return try await self.listTestGridProjects(input, logger: logger)
    }

    /// Returns a list of the actions taken in a TestGridSession.
    @Sendable
    @inlinable
    public func listTestGridSessionActions(_ input: ListTestGridSessionActionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTestGridSessionActionsResult {
        try await self.client.execute(
            operation: "ListTestGridSessionActions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of the actions taken in a TestGridSession.
    ///
    /// Parameters:
    ///   - maxResult: The maximum number of sessions to return per response.
    ///   - nextToken: Pagination token.
    ///   - sessionArn: The ARN of the session to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTestGridSessionActions(
        maxResult: Int? = nil,
        nextToken: String? = nil,
        sessionArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTestGridSessionActionsResult {
        let input = ListTestGridSessionActionsRequest(
            maxResult: maxResult, 
            nextToken: nextToken, 
            sessionArn: sessionArn
        )
        return try await self.listTestGridSessionActions(input, logger: logger)
    }

    /// Retrieves a list of artifacts created during the session.
    @Sendable
    @inlinable
    public func listTestGridSessionArtifacts(_ input: ListTestGridSessionArtifactsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTestGridSessionArtifactsResult {
        try await self.client.execute(
            operation: "ListTestGridSessionArtifacts", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of artifacts created during the session.
    ///
    /// Parameters:
    ///   - maxResult: The maximum number of results to be returned by a request.
    ///   - nextToken: Pagination token.
    ///   - sessionArn: The ARN of a TestGridSession.
    ///   - type: Limit results to a specified type of artifact.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTestGridSessionArtifacts(
        maxResult: Int? = nil,
        nextToken: String? = nil,
        sessionArn: String,
        type: TestGridSessionArtifactCategory? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTestGridSessionArtifactsResult {
        let input = ListTestGridSessionArtifactsRequest(
            maxResult: maxResult, 
            nextToken: nextToken, 
            sessionArn: sessionArn, 
            type: type
        )
        return try await self.listTestGridSessionArtifacts(input, logger: logger)
    }

    /// Retrieves a list of sessions for a TestGridProject.
    @Sendable
    @inlinable
    public func listTestGridSessions(_ input: ListTestGridSessionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTestGridSessionsResult {
        try await self.client.execute(
            operation: "ListTestGridSessions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of sessions for a TestGridProject.
    ///
    /// Parameters:
    ///   - creationTimeAfter: Return only sessions created after this time.
    ///   - creationTimeBefore: Return only  sessions created before this time.
    ///   - endTimeAfter: Return only sessions that ended after this time.
    ///   - endTimeBefore: Return only sessions that ended before this time.
    ///   - maxResult: Return only this many results at a time.
    ///   - nextToken: Pagination token.
    ///   - projectArn: ARN of a TestGridProject.
    ///   - status: Return only sessions in this state.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTestGridSessions(
        creationTimeAfter: Date? = nil,
        creationTimeBefore: Date? = nil,
        endTimeAfter: Date? = nil,
        endTimeBefore: Date? = nil,
        maxResult: Int? = nil,
        nextToken: String? = nil,
        projectArn: String,
        status: TestGridSessionStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTestGridSessionsResult {
        let input = ListTestGridSessionsRequest(
            creationTimeAfter: creationTimeAfter, 
            creationTimeBefore: creationTimeBefore, 
            endTimeAfter: endTimeAfter, 
            endTimeBefore: endTimeBefore, 
            maxResult: maxResult, 
            nextToken: nextToken, 
            projectArn: projectArn, 
            status: status
        )
        return try await self.listTestGridSessions(input, logger: logger)
    }

    /// Gets information about tests in a given test suite.
    @Sendable
    @inlinable
    public func listTests(_ input: ListTestsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTestsResult {
        try await self.client.execute(
            operation: "ListTests", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about tests in a given test suite.
    ///
    /// Parameters:
    ///   - arn: The test suite's Amazon Resource Name (ARN).
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTests(
        arn: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTestsResult {
        let input = ListTestsRequest(
            arn: arn, 
            nextToken: nextToken
        )
        return try await self.listTests(input, logger: logger)
    }

    /// Gets information about unique problems, such as exceptions or crashes. Unique problems are defined as a single instance of an error across a run, job, or suite. For example, if a call in your application consistently raises an exception (OutOfBoundsException in MyActivity.java:386), ListUniqueProblems returns a single entry instead of many individual entries for that exception.
    @Sendable
    @inlinable
    public func listUniqueProblems(_ input: ListUniqueProblemsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListUniqueProblemsResult {
        try await self.client.execute(
            operation: "ListUniqueProblems", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about unique problems, such as exceptions or crashes. Unique problems are defined as a single instance of an error across a run, job, or suite. For example, if a call in your application consistently raises an exception (OutOfBoundsException in MyActivity.java:386), ListUniqueProblems returns a single entry instead of many individual entries for that exception.
    ///
    /// Parameters:
    ///   - arn: The unique problems' ARNs.
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listUniqueProblems(
        arn: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListUniqueProblemsResult {
        let input = ListUniqueProblemsRequest(
            arn: arn, 
            nextToken: nextToken
        )
        return try await self.listUniqueProblems(input, logger: logger)
    }

    /// Gets information about uploads, given an AWS Device Farm project ARN.
    @Sendable
    @inlinable
    public func listUploads(_ input: ListUploadsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListUploadsResult {
        try await self.client.execute(
            operation: "ListUploads", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about uploads, given an AWS Device Farm project ARN.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the project for which you want to list uploads.
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - type: The type of upload. Must be one of the following values:   ANDROID_APP   IOS_APP   WEB_APP   EXTERNAL_DATA   APPIUM_JAVA_JUNIT_TEST_PACKAGE   APPIUM_JAVA_TESTNG_TEST_PACKAGE   APPIUM_PYTHON_TEST_PACKAGE   APPIUM_NODE_TEST_PACKAGE   APPIUM_RUBY_TEST_PACKAGE   APPIUM_WEB_JAVA_JUNIT_TEST_PACKAGE   APPIUM_WEB_JAVA_TESTNG_TEST_PACKAGE   APPIUM_WEB_PYTHON_TEST_PACKAGE   APPIUM_WEB_NODE_TEST_PACKAGE   APPIUM_WEB_RUBY_TEST_PACKAGE   INSTRUMENTATION_TEST_PACKAGE   XCTEST_TEST_PACKAGE   XCTEST_UI_TEST_PACKAGE   APPIUM_JAVA_JUNIT_TEST_SPEC   APPIUM_JAVA_TESTNG_TEST_SPEC   APPIUM_PYTHON_TEST_SPEC   APPIUM_NODE_TEST_SPEC   APPIUM_RUBY_TEST_SPEC   APPIUM_WEB_JAVA_JUNIT_TEST_SPEC   APPIUM_WEB_JAVA_TESTNG_TEST_SPEC   APPIUM_WEB_PYTHON_TEST_SPEC   APPIUM_WEB_NODE_TEST_SPEC   APPIUM_WEB_RUBY_TEST_SPEC   INSTRUMENTATION_TEST_SPEC   XCTEST_UI_TEST_SPEC
    ///   - logger: Logger use during operation
    @inlinable
    public func listUploads(
        arn: String,
        nextToken: String? = nil,
        type: UploadType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListUploadsResult {
        let input = ListUploadsRequest(
            arn: arn, 
            nextToken: nextToken, 
            type: type
        )
        return try await self.listUploads(input, logger: logger)
    }

    /// Returns information about all Amazon Virtual Private Cloud (VPC) endpoint configurations in the AWS account.
    @Sendable
    @inlinable
    public func listVPCEConfigurations(_ input: ListVPCEConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListVPCEConfigurationsResult {
        try await self.client.execute(
            operation: "ListVPCEConfigurations", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about all Amazon Virtual Private Cloud (VPC) endpoint configurations in the AWS account.
    ///
    /// Parameters:
    ///   - maxResults: An integer that specifies the maximum number of items you want to return in the API response.
    ///   - nextToken: An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listVPCEConfigurations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListVPCEConfigurationsResult {
        let input = ListVPCEConfigurationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listVPCEConfigurations(input, logger: logger)
    }

    /// Immediately purchases offerings for an AWS account. Offerings renew with the latest total purchased quantity for an offering, unless the renewal was overridden. The API returns a NotEligible error if the user is not permitted to invoke the operation. If you must be able to invoke this operation, contact aws-devicefarm-support@amazon.com.
    @Sendable
    @inlinable
    public func purchaseOffering(_ input: PurchaseOfferingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PurchaseOfferingResult {
        try await self.client.execute(
            operation: "PurchaseOffering", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Immediately purchases offerings for an AWS account. Offerings renew with the latest total purchased quantity for an offering, unless the renewal was overridden. The API returns a NotEligible error if the user is not permitted to invoke the operation. If you must be able to invoke this operation, contact aws-devicefarm-support@amazon.com.
    ///
    /// Parameters:
    ///   - offeringId: The ID of the offering.
    ///   - offeringPromotionId: The ID of the offering promotion to be applied to the purchase.
    ///   - quantity: The number of device slots to purchase in an offering request.
    ///   - logger: Logger use during operation
    @inlinable
    public func purchaseOffering(
        offeringId: String,
        offeringPromotionId: String? = nil,
        quantity: Int,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PurchaseOfferingResult {
        let input = PurchaseOfferingRequest(
            offeringId: offeringId, 
            offeringPromotionId: offeringPromotionId, 
            quantity: quantity
        )
        return try await self.purchaseOffering(input, logger: logger)
    }

    /// Explicitly sets the quantity of devices to renew for an offering, starting from the effectiveDate of the next period. The API returns a NotEligible error if the user is not permitted to invoke the operation. If you must be able to invoke this operation, contact aws-devicefarm-support@amazon.com.
    @Sendable
    @inlinable
    public func renewOffering(_ input: RenewOfferingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RenewOfferingResult {
        try await self.client.execute(
            operation: "RenewOffering", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Explicitly sets the quantity of devices to renew for an offering, starting from the effectiveDate of the next period. The API returns a NotEligible error if the user is not permitted to invoke the operation. If you must be able to invoke this operation, contact aws-devicefarm-support@amazon.com.
    ///
    /// Parameters:
    ///   - offeringId: The ID of a request to renew an offering.
    ///   - quantity: The quantity requested in an offering renewal.
    ///   - logger: Logger use during operation
    @inlinable
    public func renewOffering(
        offeringId: String,
        quantity: Int,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RenewOfferingResult {
        let input = RenewOfferingRequest(
            offeringId: offeringId, 
            quantity: quantity
        )
        return try await self.renewOffering(input, logger: logger)
    }

    /// Schedules a run.
    @Sendable
    @inlinable
    public func scheduleRun(_ input: ScheduleRunRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ScheduleRunResult {
        try await self.client.execute(
            operation: "ScheduleRun", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Schedules a run.
    ///
    /// Parameters:
    ///   - appArn: The ARN of an application package to run tests against, created with CreateUpload. See ListUploads.
    ///   - configuration: Information about the settings for the run to be scheduled.
    ///   - devicePoolArn: The ARN of the device pool for the run to be scheduled.
    ///   - deviceSelectionConfiguration: The filter criteria used to dynamically select a set of devices for a test run and the maximum number of devices to be included in the run. Either  devicePoolArn or  deviceSelectionConfiguration is required in a request.
    ///   - executionConfiguration: Specifies configuration information about a test run, such as the execution timeout (in minutes).
    ///   - name: The name for the run to be scheduled.
    ///   - projectArn: The ARN of the project for the run to be scheduled.
    ///   - test: Information about the test for the run to be scheduled.
    ///   - logger: Logger use during operation
    @inlinable
    public func scheduleRun(
        appArn: String? = nil,
        configuration: ScheduleRunConfiguration? = nil,
        devicePoolArn: String? = nil,
        deviceSelectionConfiguration: DeviceSelectionConfiguration? = nil,
        executionConfiguration: ExecutionConfiguration? = nil,
        name: String? = nil,
        projectArn: String,
        test: ScheduleRunTest,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ScheduleRunResult {
        let input = ScheduleRunRequest(
            appArn: appArn, 
            configuration: configuration, 
            devicePoolArn: devicePoolArn, 
            deviceSelectionConfiguration: deviceSelectionConfiguration, 
            executionConfiguration: executionConfiguration, 
            name: name, 
            projectArn: projectArn, 
            test: test
        )
        return try await self.scheduleRun(input, logger: logger)
    }

    /// Initiates a stop request for the current job. AWS Device Farm immediately stops the job on the device where tests have not started. You are not billed for this device. On the device where tests have started, setup suite and teardown suite tests run to completion on the device. You are billed for setup, teardown, and any tests that were in progress or already completed.
    @Sendable
    @inlinable
    public func stopJob(_ input: StopJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StopJobResult {
        try await self.client.execute(
            operation: "StopJob", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Initiates a stop request for the current job. AWS Device Farm immediately stops the job on the device where tests have not started. You are not billed for this device. On the device where tests have started, setup suite and teardown suite tests run to completion on the device. You are billed for setup, teardown, and any tests that were in progress or already completed.
    ///
    /// Parameters:
    ///   - arn: Represents the Amazon Resource Name (ARN) of the Device Farm job to stop.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopJob(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StopJobResult {
        let input = StopJobRequest(
            arn: arn
        )
        return try await self.stopJob(input, logger: logger)
    }

    /// Ends a specified remote access session.
    @Sendable
    @inlinable
    public func stopRemoteAccessSession(_ input: StopRemoteAccessSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StopRemoteAccessSessionResult {
        try await self.client.execute(
            operation: "StopRemoteAccessSession", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Ends a specified remote access session.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the remote access session to stop.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopRemoteAccessSession(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StopRemoteAccessSessionResult {
        let input = StopRemoteAccessSessionRequest(
            arn: arn
        )
        return try await self.stopRemoteAccessSession(input, logger: logger)
    }

    /// Initiates a stop request for the current test run. AWS Device Farm immediately stops the run on devices where tests have not started. You are not billed for these devices. On devices where tests have started executing, setup suite and teardown suite tests run to completion on those devices. You are billed for setup, teardown, and any tests that were in progress or already completed.
    @Sendable
    @inlinable
    public func stopRun(_ input: StopRunRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StopRunResult {
        try await self.client.execute(
            operation: "StopRun", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Initiates a stop request for the current test run. AWS Device Farm immediately stops the run on devices where tests have not started. You are not billed for these devices. On devices where tests have started executing, setup suite and teardown suite tests run to completion on those devices. You are billed for setup, teardown, and any tests that were in progress or already completed.
    ///
    /// Parameters:
    ///   - arn: Represents the Amazon Resource Name (ARN) of the Device Farm run to stop.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopRun(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StopRunResult {
        let input = StopRunRequest(
            arn: arn
        )
        return try await self.stopRun(input, logger: logger)
    }

    /// Associates the specified tags to a resource with the specified resourceArn. If existing tags on a resource are not specified in the request parameters, they are not changed. When a resource is deleted, the tags associated with that resource are also deleted.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates the specified tags to a resource with the specified resourceArn. If existing tags on a resource are not specified in the request parameters, they are not changed. When a resource is deleted, the tags associated with that resource are also deleted.
    ///
    /// Parameters:
    ///   - resourceARN: The Amazon Resource Name (ARN) of the resource or resources to which to add tags. You can associate tags with the following Device Farm resources: PROJECT, RUN, NETWORK_PROFILE, INSTANCE_PROFILE, DEVICE_INSTANCE, SESSION, DEVICE_POOL, DEVICE, and VPCE_CONFIGURATION.
    ///   - tags: The tags to add to the resource. A tag is an array of key-value pairs. Tag keys can have a maximum character length of 128 characters. Tag values can have a maximum length of 256 characters.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceARN: String,
        tags: [Tag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceARN: resourceARN, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Deletes the specified tags from a resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified tags from a resource.
    ///
    /// Parameters:
    ///   - resourceARN: The Amazon Resource Name (ARN) of the resource or resources from which to delete tags. You can associate tags with the following Device Farm resources: PROJECT, RUN, NETWORK_PROFILE, INSTANCE_PROFILE, DEVICE_INSTANCE, SESSION, DEVICE_POOL, DEVICE, and VPCE_CONFIGURATION.
    ///   - tagKeys: The keys of the tags to be removed.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceARN: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceARN: resourceARN, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates information about a private device instance.
    @Sendable
    @inlinable
    public func updateDeviceInstance(_ input: UpdateDeviceInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateDeviceInstanceResult {
        try await self.client.execute(
            operation: "UpdateDeviceInstance", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates information about a private device instance.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the device instance.
    ///   - labels: An array of strings that you want to associate with the device instance.
    ///   - profileArn: The ARN of the profile that you want to associate with the device instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDeviceInstance(
        arn: String,
        labels: [String]? = nil,
        profileArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateDeviceInstanceResult {
        let input = UpdateDeviceInstanceRequest(
            arn: arn, 
            labels: labels, 
            profileArn: profileArn
        )
        return try await self.updateDeviceInstance(input, logger: logger)
    }

    /// Modifies the name, description, and rules in a device pool given the attributes and the pool ARN. Rule updates are all-or-nothing, meaning they can only be updated as a whole (or not at all).
    @Sendable
    @inlinable
    public func updateDevicePool(_ input: UpdateDevicePoolRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateDevicePoolResult {
        try await self.client.execute(
            operation: "UpdateDevicePool", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies the name, description, and rules in a device pool given the attributes and the pool ARN. Rule updates are all-or-nothing, meaning they can only be updated as a whole (or not at all).
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the Device Farm device pool to update.
    ///   - clearMaxDevices: Sets whether the maxDevices parameter applies to your device pool. If you set this parameter to true, the maxDevices parameter does not apply, and Device Farm does not limit the number of devices that it adds to your device pool. In this case, Device Farm adds all available devices that meet the criteria specified in the rules parameter. If you use this parameter in your request, you cannot use the maxDevices parameter in the same request.
    ///   - description: A description of the device pool to update.
    ///   - maxDevices: The number of devices that Device Farm can add to your device pool. Device Farm adds devices that are available and that meet the criteria that you assign for the rules parameter. Depending on how many devices meet these constraints, your device pool might contain fewer devices than the value for this parameter. By specifying the maximum number of devices, you can control the costs that you incur by running tests. If you use this parameter in your request, you cannot use the clearMaxDevices parameter in the same request.
    ///   - name: A string that represents the name of the device pool to update.
    ///   - rules: Represents the rules to modify for the device pool. Updating rules is optional. If you update rules for your request, the update replaces the existing rules.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDevicePool(
        arn: String,
        clearMaxDevices: Bool? = nil,
        description: String? = nil,
        maxDevices: Int? = nil,
        name: String? = nil,
        rules: [Rule]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateDevicePoolResult {
        let input = UpdateDevicePoolRequest(
            arn: arn, 
            clearMaxDevices: clearMaxDevices, 
            description: description, 
            maxDevices: maxDevices, 
            name: name, 
            rules: rules
        )
        return try await self.updateDevicePool(input, logger: logger)
    }

    /// Updates information about an existing private device instance profile.
    @Sendable
    @inlinable
    public func updateInstanceProfile(_ input: UpdateInstanceProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateInstanceProfileResult {
        try await self.client.execute(
            operation: "UpdateInstanceProfile", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates information about an existing private device instance profile.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the instance profile.
    ///   - description: The updated description for your instance profile.
    ///   - excludeAppPackagesFromCleanup: An array of strings that specifies the list of app packages that should not be cleaned up from the device after a test run is over. The list of packages is only considered if you set packageCleanup to true.
    ///   - name: The updated name for your instance profile.
    ///   - packageCleanup: The updated choice for whether you want to specify package cleanup. The default value is false for private devices.
    ///   - rebootAfterUse: The updated choice for whether you want to reboot the device after use. The default value is true.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateInstanceProfile(
        arn: String,
        description: String? = nil,
        excludeAppPackagesFromCleanup: [String]? = nil,
        name: String? = nil,
        packageCleanup: Bool? = nil,
        rebootAfterUse: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateInstanceProfileResult {
        let input = UpdateInstanceProfileRequest(
            arn: arn, 
            description: description, 
            excludeAppPackagesFromCleanup: excludeAppPackagesFromCleanup, 
            name: name, 
            packageCleanup: packageCleanup, 
            rebootAfterUse: rebootAfterUse
        )
        return try await self.updateInstanceProfile(input, logger: logger)
    }

    /// Updates the network profile.
    @Sendable
    @inlinable
    public func updateNetworkProfile(_ input: UpdateNetworkProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateNetworkProfileResult {
        try await self.client.execute(
            operation: "UpdateNetworkProfile", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the network profile.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the project for which you want to update network profile settings.
    ///   - description: The description of the network profile about which you are returning information.
    ///   - downlinkBandwidthBits: The data throughput rate in bits per second, as an integer from 0 to 104857600.
    ///   - downlinkDelayMs: Delay time for all packets to destination in milliseconds as an integer from 0 to 2000.
    ///   - downlinkJitterMs: Time variation in the delay of received packets in milliseconds as an integer from 0 to 2000.
    ///   - downlinkLossPercent: Proportion of received packets that fail to arrive from 0 to 100 percent.
    ///   - name: The name of the network profile about which you are returning information.
    ///   - type: The type of network profile to return information about. Valid values are listed here.
    ///   - uplinkBandwidthBits: The data throughput rate in bits per second, as an integer from 0 to 104857600.
    ///   - uplinkDelayMs: Delay time for all packets to destination in milliseconds as an integer from 0 to 2000.
    ///   - uplinkJitterMs: Time variation in the delay of received packets in milliseconds as an integer from 0 to 2000.
    ///   - uplinkLossPercent: Proportion of transmitted packets that fail to arrive from 0 to 100 percent.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateNetworkProfile(
        arn: String,
        description: String? = nil,
        downlinkBandwidthBits: Int64? = nil,
        downlinkDelayMs: Int64? = nil,
        downlinkJitterMs: Int64? = nil,
        downlinkLossPercent: Int? = nil,
        name: String? = nil,
        type: NetworkProfileType? = nil,
        uplinkBandwidthBits: Int64? = nil,
        uplinkDelayMs: Int64? = nil,
        uplinkJitterMs: Int64? = nil,
        uplinkLossPercent: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateNetworkProfileResult {
        let input = UpdateNetworkProfileRequest(
            arn: arn, 
            description: description, 
            downlinkBandwidthBits: downlinkBandwidthBits, 
            downlinkDelayMs: downlinkDelayMs, 
            downlinkJitterMs: downlinkJitterMs, 
            downlinkLossPercent: downlinkLossPercent, 
            name: name, 
            type: type, 
            uplinkBandwidthBits: uplinkBandwidthBits, 
            uplinkDelayMs: uplinkDelayMs, 
            uplinkJitterMs: uplinkJitterMs, 
            uplinkLossPercent: uplinkLossPercent
        )
        return try await self.updateNetworkProfile(input, logger: logger)
    }

    /// Modifies the specified project name, given the project ARN and a new name.
    @Sendable
    @inlinable
    public func updateProject(_ input: UpdateProjectRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateProjectResult {
        try await self.client.execute(
            operation: "UpdateProject", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies the specified project name, given the project ARN and a new name.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the project whose name to update.
    ///   - defaultJobTimeoutMinutes: The number of minutes a test run in the project executes before it times out.
    ///   - name: A string that represents the new name of the project that you are updating.
    ///   - vpcConfig: The VPC security groups and subnets that are attached to a project.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateProject(
        arn: String,
        defaultJobTimeoutMinutes: Int? = nil,
        name: String? = nil,
        vpcConfig: VpcConfig? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateProjectResult {
        let input = UpdateProjectRequest(
            arn: arn, 
            defaultJobTimeoutMinutes: defaultJobTimeoutMinutes, 
            name: name, 
            vpcConfig: vpcConfig
        )
        return try await self.updateProject(input, logger: logger)
    }

    /// Change details of a project.
    @Sendable
    @inlinable
    public func updateTestGridProject(_ input: UpdateTestGridProjectRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateTestGridProjectResult {
        try await self.client.execute(
            operation: "UpdateTestGridProject", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Change details of a project.
    ///
    /// Parameters:
    ///   - description: Human-readable description for the project.
    ///   - name: Human-readable name for the project.
    ///   - projectArn: ARN of the project to update.
    ///   - vpcConfig: The VPC security groups and subnets that are attached to a project.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateTestGridProject(
        description: String? = nil,
        name: String? = nil,
        projectArn: String,
        vpcConfig: TestGridVpcConfig? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateTestGridProjectResult {
        let input = UpdateTestGridProjectRequest(
            description: description, 
            name: name, 
            projectArn: projectArn, 
            vpcConfig: vpcConfig
        )
        return try await self.updateTestGridProject(input, logger: logger)
    }

    /// Updates an uploaded test spec.
    @Sendable
    @inlinable
    public func updateUpload(_ input: UpdateUploadRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateUploadResult {
        try await self.client.execute(
            operation: "UpdateUpload", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an uploaded test spec.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the uploaded test spec.
    ///   - contentType: The upload's content type (for example, application/x-yaml).
    ///   - editContent: Set to true if the YAML file has changed and must be updated. Otherwise, set to false.
    ///   - name: The upload's test spec file name. The name must not contain any forward slashes (/). The test spec file name must end with the .yaml or .yml file extension.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateUpload(
        arn: String,
        contentType: String? = nil,
        editContent: Bool? = nil,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateUploadResult {
        let input = UpdateUploadRequest(
            arn: arn, 
            contentType: contentType, 
            editContent: editContent, 
            name: name
        )
        return try await self.updateUpload(input, logger: logger)
    }

    /// Updates information about an Amazon Virtual Private Cloud (VPC) endpoint configuration.
    @Sendable
    @inlinable
    public func updateVPCEConfiguration(_ input: UpdateVPCEConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateVPCEConfigurationResult {
        try await self.client.execute(
            operation: "UpdateVPCEConfiguration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates information about an Amazon Virtual Private Cloud (VPC) endpoint configuration.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the VPC endpoint configuration you want to update.
    ///   - serviceDnsName: The DNS (domain) name used to connect to your private service in your VPC. The DNS name must not already be in use on the internet.
    ///   - vpceConfigurationDescription: An optional description that provides details about your VPC endpoint configuration.
    ///   - vpceConfigurationName: The friendly name you give to your VPC endpoint configuration to manage your configurations more easily.
    ///   - vpceServiceName: The name of the VPC endpoint service running in your AWS account that you want Device Farm to test.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateVPCEConfiguration(
        arn: String,
        serviceDnsName: String? = nil,
        vpceConfigurationDescription: String? = nil,
        vpceConfigurationName: String? = nil,
        vpceServiceName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateVPCEConfigurationResult {
        let input = UpdateVPCEConfigurationRequest(
            arn: arn, 
            serviceDnsName: serviceDnsName, 
            vpceConfigurationDescription: vpceConfigurationDescription, 
            vpceConfigurationName: vpceConfigurationName, 
            vpceServiceName: vpceServiceName
        )
        return try await self.updateVPCEConfiguration(input, logger: logger)
    }
}

extension DeviceFarm {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: DeviceFarm, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension DeviceFarm {
    /// Return PaginatorSequence for operation ``getOfferingStatus(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getOfferingStatusPaginator(
        _ input: GetOfferingStatusRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetOfferingStatusRequest, GetOfferingStatusResult> {
        return .init(
            input: input,
            command: self.getOfferingStatus,
            inputKey: \GetOfferingStatusRequest.nextToken,
            outputKey: \GetOfferingStatusResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getOfferingStatus(_:logger:)``.
    ///
    /// - Parameters:
    ///   - logger: Logger used for logging
    @inlinable
    public func getOfferingStatusPaginator(
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetOfferingStatusRequest, GetOfferingStatusResult> {
        let input = GetOfferingStatusRequest(
        )
        return self.getOfferingStatusPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listArtifacts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listArtifactsPaginator(
        _ input: ListArtifactsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListArtifactsRequest, ListArtifactsResult> {
        return .init(
            input: input,
            command: self.listArtifacts,
            inputKey: \ListArtifactsRequest.nextToken,
            outputKey: \ListArtifactsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listArtifacts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - arn: The run, job, suite, or test ARN.
    ///   - type: The artifacts' type. Allowed values include:   FILE   LOG   SCREENSHOT
    ///   - logger: Logger used for logging
    @inlinable
    public func listArtifactsPaginator(
        arn: String,
        type: ArtifactCategory,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListArtifactsRequest, ListArtifactsResult> {
        let input = ListArtifactsRequest(
            arn: arn, 
            type: type
        )
        return self.listArtifactsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDevicePools(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDevicePoolsPaginator(
        _ input: ListDevicePoolsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDevicePoolsRequest, ListDevicePoolsResult> {
        return .init(
            input: input,
            command: self.listDevicePools,
            inputKey: \ListDevicePoolsRequest.nextToken,
            outputKey: \ListDevicePoolsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDevicePools(_:logger:)``.
    ///
    /// - Parameters:
    ///   - arn: The project ARN.
    ///   - type: The device pools' type. Allowed values include:   CURATED: A device pool that is created and managed by AWS Device Farm.   PRIVATE: A device pool that is created and managed by the device pool developer.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDevicePoolsPaginator(
        arn: String,
        type: DevicePoolType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDevicePoolsRequest, ListDevicePoolsResult> {
        let input = ListDevicePoolsRequest(
            arn: arn, 
            type: type
        )
        return self.listDevicePoolsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDevices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDevicesPaginator(
        _ input: ListDevicesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDevicesRequest, ListDevicesResult> {
        return .init(
            input: input,
            command: self.listDevices,
            inputKey: \ListDevicesRequest.nextToken,
            outputKey: \ListDevicesResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDevices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the project.
    ///   - filters: Used to select a set of devices. A filter is made up of an attribute, an operator, and one or more values.   Attribute: The aspect of a device such as platform or model used as the selection criteria in a device filter. Allowed values include:   ARN: The Amazon Resource Name (ARN) of the device (for example, arn:aws:devicefarm:us-west-2::device:12345Example).   PLATFORM: The device platform. Valid values are ANDROID or IOS.   OS_VERSION: The operating system version (for example, 10.3.2).   MODEL: The device model (for example, iPad 5th Gen).   AVAILABILITY: The current availability of the device. Valid values are AVAILABLE, HIGHLY_AVAILABLE, BUSY, or TEMPORARY_NOT_AVAILABLE.   FORM_FACTOR: The device form factor. Valid values are PHONE or TABLET.   MANUFACTURER: The device manufacturer (for example, Apple).   REMOTE_ACCESS_ENABLED: Whether the device is enabled for remote access. Valid values are TRUE or FALSE.   REMOTE_DEBUG_ENABLED: Whether the device is enabled for remote debugging. Valid values are TRUE or FALSE. Because remote debugging is no longer supported, this attribute is ignored.   INSTANCE_ARN: The Amazon Resource Name (ARN) of the device instance.   INSTANCE_LABELS: The label of the device instance.   FLEET_TYPE: The fleet type. Valid values are PUBLIC or PRIVATE.     Operator: The filter operator.   The EQUALS operator is available for every attribute except INSTANCE_LABELS.   The CONTAINS operator is available for the INSTANCE_LABELS and MODEL attributes.   The IN and NOT_IN operators are available for the ARN, OS_VERSION, MODEL, MANUFACTURER, and INSTANCE_ARN attributes.   The LESS_THAN, GREATER_THAN, LESS_THAN_OR_EQUALS, and GREATER_THAN_OR_EQUALS operators are also available for the OS_VERSION attribute.     Values: An array of one or more filter values.   The IN and NOT_IN operators take a values array that has one or more elements.   The other operators require an array with a single element.   In a request, the AVAILABILITY attribute takes the following values: AVAILABLE, HIGHLY_AVAILABLE, BUSY, or TEMPORARY_NOT_AVAILABLE.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDevicesPaginator(
        arn: String? = nil,
        filters: [DeviceFilter]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDevicesRequest, ListDevicesResult> {
        let input = ListDevicesRequest(
            arn: arn, 
            filters: filters
        )
        return self.listDevicesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listJobsPaginator(
        _ input: ListJobsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListJobsRequest, ListJobsResult> {
        return .init(
            input: input,
            command: self.listJobs,
            inputKey: \ListJobsRequest.nextToken,
            outputKey: \ListJobsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - arn: The run's Amazon Resource Name (ARN).
    ///   - logger: Logger used for logging
    @inlinable
    public func listJobsPaginator(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListJobsRequest, ListJobsResult> {
        let input = ListJobsRequest(
            arn: arn
        )
        return self.listJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listOfferingTransactions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listOfferingTransactionsPaginator(
        _ input: ListOfferingTransactionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListOfferingTransactionsRequest, ListOfferingTransactionsResult> {
        return .init(
            input: input,
            command: self.listOfferingTransactions,
            inputKey: \ListOfferingTransactionsRequest.nextToken,
            outputKey: \ListOfferingTransactionsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listOfferingTransactions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - logger: Logger used for logging
    @inlinable
    public func listOfferingTransactionsPaginator(
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListOfferingTransactionsRequest, ListOfferingTransactionsResult> {
        let input = ListOfferingTransactionsRequest(
        )
        return self.listOfferingTransactionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listOfferings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listOfferingsPaginator(
        _ input: ListOfferingsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListOfferingsRequest, ListOfferingsResult> {
        return .init(
            input: input,
            command: self.listOfferings,
            inputKey: \ListOfferingsRequest.nextToken,
            outputKey: \ListOfferingsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listOfferings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - logger: Logger used for logging
    @inlinable
    public func listOfferingsPaginator(
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListOfferingsRequest, ListOfferingsResult> {
        let input = ListOfferingsRequest(
        )
        return self.listOfferingsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listProjects(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listProjectsPaginator(
        _ input: ListProjectsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListProjectsRequest, ListProjectsResult> {
        return .init(
            input: input,
            command: self.listProjects,
            inputKey: \ListProjectsRequest.nextToken,
            outputKey: \ListProjectsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listProjects(_:logger:)``.
    ///
    /// - Parameters:
    ///   - arn: Optional. If no Amazon Resource Name (ARN) is specified, then AWS Device Farm returns a list of all projects for the AWS account. You can also specify a project ARN.
    ///   - logger: Logger used for logging
    @inlinable
    public func listProjectsPaginator(
        arn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListProjectsRequest, ListProjectsResult> {
        let input = ListProjectsRequest(
            arn: arn
        )
        return self.listProjectsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRuns(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRunsPaginator(
        _ input: ListRunsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRunsRequest, ListRunsResult> {
        return .init(
            input: input,
            command: self.listRuns,
            inputKey: \ListRunsRequest.nextToken,
            outputKey: \ListRunsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRuns(_:logger:)``.
    ///
    /// - Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the project for which you want to list runs.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRunsPaginator(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRunsRequest, ListRunsResult> {
        let input = ListRunsRequest(
            arn: arn
        )
        return self.listRunsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSamples(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSamplesPaginator(
        _ input: ListSamplesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSamplesRequest, ListSamplesResult> {
        return .init(
            input: input,
            command: self.listSamples,
            inputKey: \ListSamplesRequest.nextToken,
            outputKey: \ListSamplesResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSamples(_:logger:)``.
    ///
    /// - Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the job used to list samples.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSamplesPaginator(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSamplesRequest, ListSamplesResult> {
        let input = ListSamplesRequest(
            arn: arn
        )
        return self.listSamplesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSuites(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSuitesPaginator(
        _ input: ListSuitesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSuitesRequest, ListSuitesResult> {
        return .init(
            input: input,
            command: self.listSuites,
            inputKey: \ListSuitesRequest.nextToken,
            outputKey: \ListSuitesResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSuites(_:logger:)``.
    ///
    /// - Parameters:
    ///   - arn: The job's Amazon Resource Name (ARN).
    ///   - logger: Logger used for logging
    @inlinable
    public func listSuitesPaginator(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSuitesRequest, ListSuitesResult> {
        let input = ListSuitesRequest(
            arn: arn
        )
        return self.listSuitesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTestGridProjects(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTestGridProjectsPaginator(
        _ input: ListTestGridProjectsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTestGridProjectsRequest, ListTestGridProjectsResult> {
        return .init(
            input: input,
            command: self.listTestGridProjects,
            inputKey: \ListTestGridProjectsRequest.nextToken,
            outputKey: \ListTestGridProjectsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTestGridProjects(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResult: Return no more than this number of results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listTestGridProjectsPaginator(
        maxResult: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTestGridProjectsRequest, ListTestGridProjectsResult> {
        let input = ListTestGridProjectsRequest(
            maxResult: maxResult
        )
        return self.listTestGridProjectsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTestGridSessionActions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTestGridSessionActionsPaginator(
        _ input: ListTestGridSessionActionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTestGridSessionActionsRequest, ListTestGridSessionActionsResult> {
        return .init(
            input: input,
            command: self.listTestGridSessionActions,
            inputKey: \ListTestGridSessionActionsRequest.nextToken,
            outputKey: \ListTestGridSessionActionsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTestGridSessionActions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResult: The maximum number of sessions to return per response.
    ///   - sessionArn: The ARN of the session to retrieve.
    ///   - logger: Logger used for logging
    @inlinable
    public func listTestGridSessionActionsPaginator(
        maxResult: Int? = nil,
        sessionArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTestGridSessionActionsRequest, ListTestGridSessionActionsResult> {
        let input = ListTestGridSessionActionsRequest(
            maxResult: maxResult, 
            sessionArn: sessionArn
        )
        return self.listTestGridSessionActionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTestGridSessionArtifacts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTestGridSessionArtifactsPaginator(
        _ input: ListTestGridSessionArtifactsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTestGridSessionArtifactsRequest, ListTestGridSessionArtifactsResult> {
        return .init(
            input: input,
            command: self.listTestGridSessionArtifacts,
            inputKey: \ListTestGridSessionArtifactsRequest.nextToken,
            outputKey: \ListTestGridSessionArtifactsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTestGridSessionArtifacts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResult: The maximum number of results to be returned by a request.
    ///   - sessionArn: The ARN of a TestGridSession.
    ///   - type: Limit results to a specified type of artifact.
    ///   - logger: Logger used for logging
    @inlinable
    public func listTestGridSessionArtifactsPaginator(
        maxResult: Int? = nil,
        sessionArn: String,
        type: TestGridSessionArtifactCategory? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTestGridSessionArtifactsRequest, ListTestGridSessionArtifactsResult> {
        let input = ListTestGridSessionArtifactsRequest(
            maxResult: maxResult, 
            sessionArn: sessionArn, 
            type: type
        )
        return self.listTestGridSessionArtifactsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTestGridSessions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTestGridSessionsPaginator(
        _ input: ListTestGridSessionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTestGridSessionsRequest, ListTestGridSessionsResult> {
        return .init(
            input: input,
            command: self.listTestGridSessions,
            inputKey: \ListTestGridSessionsRequest.nextToken,
            outputKey: \ListTestGridSessionsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTestGridSessions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - creationTimeAfter: Return only sessions created after this time.
    ///   - creationTimeBefore: Return only  sessions created before this time.
    ///   - endTimeAfter: Return only sessions that ended after this time.
    ///   - endTimeBefore: Return only sessions that ended before this time.
    ///   - maxResult: Return only this many results at a time.
    ///   - projectArn: ARN of a TestGridProject.
    ///   - status: Return only sessions in this state.
    ///   - logger: Logger used for logging
    @inlinable
    public func listTestGridSessionsPaginator(
        creationTimeAfter: Date? = nil,
        creationTimeBefore: Date? = nil,
        endTimeAfter: Date? = nil,
        endTimeBefore: Date? = nil,
        maxResult: Int? = nil,
        projectArn: String,
        status: TestGridSessionStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTestGridSessionsRequest, ListTestGridSessionsResult> {
        let input = ListTestGridSessionsRequest(
            creationTimeAfter: creationTimeAfter, 
            creationTimeBefore: creationTimeBefore, 
            endTimeAfter: endTimeAfter, 
            endTimeBefore: endTimeBefore, 
            maxResult: maxResult, 
            projectArn: projectArn, 
            status: status
        )
        return self.listTestGridSessionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTests(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTestsPaginator(
        _ input: ListTestsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTestsRequest, ListTestsResult> {
        return .init(
            input: input,
            command: self.listTests,
            inputKey: \ListTestsRequest.nextToken,
            outputKey: \ListTestsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTests(_:logger:)``.
    ///
    /// - Parameters:
    ///   - arn: The test suite's Amazon Resource Name (ARN).
    ///   - logger: Logger used for logging
    @inlinable
    public func listTestsPaginator(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTestsRequest, ListTestsResult> {
        let input = ListTestsRequest(
            arn: arn
        )
        return self.listTestsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listUniqueProblems(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listUniqueProblemsPaginator(
        _ input: ListUniqueProblemsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListUniqueProblemsRequest, ListUniqueProblemsResult> {
        return .init(
            input: input,
            command: self.listUniqueProblems,
            inputKey: \ListUniqueProblemsRequest.nextToken,
            outputKey: \ListUniqueProblemsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listUniqueProblems(_:logger:)``.
    ///
    /// - Parameters:
    ///   - arn: The unique problems' ARNs.
    ///   - logger: Logger used for logging
    @inlinable
    public func listUniqueProblemsPaginator(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListUniqueProblemsRequest, ListUniqueProblemsResult> {
        let input = ListUniqueProblemsRequest(
            arn: arn
        )
        return self.listUniqueProblemsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listUploads(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listUploadsPaginator(
        _ input: ListUploadsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListUploadsRequest, ListUploadsResult> {
        return .init(
            input: input,
            command: self.listUploads,
            inputKey: \ListUploadsRequest.nextToken,
            outputKey: \ListUploadsResult.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listUploads(_:logger:)``.
    ///
    /// - Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the project for which you want to list uploads.
    ///   - type: The type of upload. Must be one of the following values:   ANDROID_APP   IOS_APP   WEB_APP   EXTERNAL_DATA   APPIUM_JAVA_JUNIT_TEST_PACKAGE   APPIUM_JAVA_TESTNG_TEST_PACKAGE   APPIUM_PYTHON_TEST_PACKAGE   APPIUM_NODE_TEST_PACKAGE   APPIUM_RUBY_TEST_PACKAGE   APPIUM_WEB_JAVA_JUNIT_TEST_PACKAGE   APPIUM_WEB_JAVA_TESTNG_TEST_PACKAGE   APPIUM_WEB_PYTHON_TEST_PACKAGE   APPIUM_WEB_NODE_TEST_PACKAGE   APPIUM_WEB_RUBY_TEST_PACKAGE   INSTRUMENTATION_TEST_PACKAGE   XCTEST_TEST_PACKAGE   XCTEST_UI_TEST_PACKAGE   APPIUM_JAVA_JUNIT_TEST_SPEC   APPIUM_JAVA_TESTNG_TEST_SPEC   APPIUM_PYTHON_TEST_SPEC   APPIUM_NODE_TEST_SPEC   APPIUM_RUBY_TEST_SPEC   APPIUM_WEB_JAVA_JUNIT_TEST_SPEC   APPIUM_WEB_JAVA_TESTNG_TEST_SPEC   APPIUM_WEB_PYTHON_TEST_SPEC   APPIUM_WEB_NODE_TEST_SPEC   APPIUM_WEB_RUBY_TEST_SPEC   INSTRUMENTATION_TEST_SPEC   XCTEST_UI_TEST_SPEC
    ///   - logger: Logger used for logging
    @inlinable
    public func listUploadsPaginator(
        arn: String,
        type: UploadType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListUploadsRequest, ListUploadsResult> {
        let input = ListUploadsRequest(
            arn: arn, 
            type: type
        )
        return self.listUploadsPaginator(input, logger: logger)
    }
}

extension DeviceFarm.GetOfferingStatusRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.GetOfferingStatusRequest {
        return .init(
            nextToken: token
        )
    }
}

extension DeviceFarm.ListArtifactsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListArtifactsRequest {
        return .init(
            arn: self.arn,
            nextToken: token,
            type: self.type
        )
    }
}

extension DeviceFarm.ListDevicePoolsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListDevicePoolsRequest {
        return .init(
            arn: self.arn,
            nextToken: token,
            type: self.type
        )
    }
}

extension DeviceFarm.ListDevicesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListDevicesRequest {
        return .init(
            arn: self.arn,
            filters: self.filters,
            nextToken: token
        )
    }
}

extension DeviceFarm.ListJobsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListJobsRequest {
        return .init(
            arn: self.arn,
            nextToken: token
        )
    }
}

extension DeviceFarm.ListOfferingTransactionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListOfferingTransactionsRequest {
        return .init(
            nextToken: token
        )
    }
}

extension DeviceFarm.ListOfferingsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListOfferingsRequest {
        return .init(
            nextToken: token
        )
    }
}

extension DeviceFarm.ListProjectsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListProjectsRequest {
        return .init(
            arn: self.arn,
            nextToken: token
        )
    }
}

extension DeviceFarm.ListRunsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListRunsRequest {
        return .init(
            arn: self.arn,
            nextToken: token
        )
    }
}

extension DeviceFarm.ListSamplesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListSamplesRequest {
        return .init(
            arn: self.arn,
            nextToken: token
        )
    }
}

extension DeviceFarm.ListSuitesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListSuitesRequest {
        return .init(
            arn: self.arn,
            nextToken: token
        )
    }
}

extension DeviceFarm.ListTestGridProjectsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListTestGridProjectsRequest {
        return .init(
            maxResult: self.maxResult,
            nextToken: token
        )
    }
}

extension DeviceFarm.ListTestGridSessionActionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListTestGridSessionActionsRequest {
        return .init(
            maxResult: self.maxResult,
            nextToken: token,
            sessionArn: self.sessionArn
        )
    }
}

extension DeviceFarm.ListTestGridSessionArtifactsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListTestGridSessionArtifactsRequest {
        return .init(
            maxResult: self.maxResult,
            nextToken: token,
            sessionArn: self.sessionArn,
            type: self.type
        )
    }
}

extension DeviceFarm.ListTestGridSessionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListTestGridSessionsRequest {
        return .init(
            creationTimeAfter: self.creationTimeAfter,
            creationTimeBefore: self.creationTimeBefore,
            endTimeAfter: self.endTimeAfter,
            endTimeBefore: self.endTimeBefore,
            maxResult: self.maxResult,
            nextToken: token,
            projectArn: self.projectArn,
            status: self.status
        )
    }
}

extension DeviceFarm.ListTestsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListTestsRequest {
        return .init(
            arn: self.arn,
            nextToken: token
        )
    }
}

extension DeviceFarm.ListUniqueProblemsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListUniqueProblemsRequest {
        return .init(
            arn: self.arn,
            nextToken: token
        )
    }
}

extension DeviceFarm.ListUploadsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DeviceFarm.ListUploadsRequest {
        return .init(
            arn: self.arn,
            nextToken: token,
            type: self.type
        )
    }
}
